package com.hospital.common.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 时间工具类：支持将时间统一处理为“当天00:00:00”或“当天23:59:59”
 */
public class TimeUtils {
    // 定义解析器和对应的处理逻辑（复用原有解析逻辑，避免重复代码）
    private static final List<Parser> PARSERS = new ArrayList<>();

    // 静态内部类：封装解析器和处理逻辑（判断是否为纯日期格式）
    private static class Parser {
        private final DateTimeFormatter formatter;
        private final boolean isDateOnly; // 标记是否为纯日期格式（如 yyyy-MM-dd）

        public Parser(String pattern, boolean isDateOnly) {
            this.formatter = DateTimeFormatter.ofPattern(pattern);
            this.isDateOnly = isDateOnly;
        }

        public LocalDateTime parse(String input) {
            if (isDateOnly) {
                // 纯日期格式：解析为LocalDate后转为LocalDateTime（默认00:00:00，后续按需调整）
                return LocalDate.parse(input, formatter).atStartOfDay();
            } else {
                // 带时间格式：解析后截断到“天”（只保留日期部分，时间重置为00:00:00，后续按需调整）
                return LocalDateTime.parse(input, formatter).truncatedTo(ChronoUnit.DAYS);
            }
        }
    }

    // 静态初始化：支持3种输入格式（与原有逻辑完全一致，保证兼容性）
    static {
        PARSERS.add(new Parser("yyyy-MM-dd", true));          // 纯日期（如 2025-09-12）
        PARSERS.add(new Parser("yyyy-MM-dd'T'HH:mm:ss", false));// 带T分隔的时间（如 2025-09-12T10:02:23）
        PARSERS.add(new Parser("yyyy-MM-dd HH:mm:ss", false)); // 带空格分隔的时间（如 2025-09-12 10:02:23）
        PARSERS.add(new Parser("yyyy-MM-dd HH-mm-ss", false)); // 添加横杠分隔的时间格式

    }

    /**
     * 原有方法：将输入时间转为“当天00:00:00”
     * @param inputTime 输入时间字符串（支持3种格式）
     * @return 格式化后的时间（如 2025-09-12 00:00:00）
     */
    public static String formatToStartOfDay(String inputTime) {
        LocalDateTime dateTime = parseInputToLocalDateTime(inputTime);
        // 直接返回00:00:00格式（解析后已默认是00:00:00，无需额外调整）
        return dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 新增方法：将输入时间转为“当天23:59:59”
     * @param inputTime 输入时间字符串（支持3种格式，与原有方法一致）
     * @return 格式化后的时间（如 2025-09-12 23:59:59）
     */
    public static String formatToEndOfDay(String inputTime) {
        LocalDateTime dateTime = parseInputToLocalDateTime(inputTime);
        // 核心：将“当天00:00:00”调整为“当天23:59:59”
        LocalDateTime endOfDay = dateTime.with(LocalTime.MAX);
        // 格式化为目标字符串
        return endOfDay.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 通用解析方法：复用解析逻辑，避免代码重复（内部工具方法，不对外暴露）
     * @param inputTime 输入时间字符串
     * @return 解析后的LocalDateTime（已截断到“天”，时间部分为00:00:00）
     */
    private static LocalDateTime parseInputToLocalDateTime(String inputTime) {
        // 遍历所有解析器尝试解析（与原有逻辑一致，保证兼容性）
        for (Parser parser : PARSERS) {
            try {
                return parser.parse(inputTime);
            } catch (Exception e) {
                // 解析失败，尝试下一个解析器（如“2025-09-12”失败，再试“2025-09-12T10:02:23”）
                continue;
            }
        }
        // 所有解析器都失败时，抛出明确的异常提示
        throw new IllegalArgumentException(
                "输入格式错误：" + inputTime +
                        "，支持格式：2025-09-12、2025-09-12T10:02:23、2025-09-12 10:02:23"
        );
    }
    // ------------------- 核心：拼接当前日期的方法 -------------------
    /**
     * 拼接当前日期 + 时间段的【开始时间】（如 2025-09-16 08:00:00）
     * @return 完整的开始时间字符串
     */
    public static String getStartDateTimeWithToday(String time) {
        // 1. 获取当前日期（如 2025-09-16）
        LocalDate today = LocalDate.now();
        // 2. 拆分时间范围，获取开始时间（如 "08:00"）
        String startTimeStr = time.split("-")[0];
        // 3. 解析开始时间为 LocalTime（如 08:00:00）
        LocalTime startTime = LocalTime.parse(startTimeStr, DateTimeFormatter.ofPattern("HH:mm"));
        // 4. 拼接日期和时间，转为字符串
        LocalDateTime startDateTime = LocalDateTime.of(today, startTime);
        return startDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 拼接当前日期 + 时间段的【结束时间】（如 2025-09-16 09:00:00）
     * @return 完整的结束时间字符串
     */
    public static String  getEndDateTimeWithToday(String time) {
        LocalDate today = LocalDate.now();
        // 拆分时间范围，获取结束时间（如 "09:00"）
        String endTimeStr = time.split("-")[1];
        LocalTime endTime = LocalTime.parse(endTimeStr, DateTimeFormatter.ofPattern("HH:mm"));
        LocalDateTime endDateTime = LocalDateTime.of(today, endTime);
        return endDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    }

    /**
     *  时间戳转字符串
     * @param ms
     * @return
     */
    public static String longDataTimeString(Long ms){
        Date date = new Date(ms);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
        return format.format(date);
    }

    /**
     *  时间戳转字符串 到天
     * @param ms
     * @return
     */
    public static String longDataString(Long ms){
        Date date = new Date(ms);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        return format.format(date);
    }

    /**
     *  比较时间
     * @param startTime
     * @param endTime
     * @return
     */
    public static boolean compareDateString(String startTime,String endTime){
        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date startDate = (Date) format.parse(startTime);
            Date endDate = (Date) format.parse(endTime);
            //拿他们的毫秒数比较
            return startDate.getTime()<endDate.getTime();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }
    /**
     * 生成从指定日期开始的连续7天日期字符串列表
     * @param startDateTimeStr 开始日期时间字符串
     * @return 连续7天的日期字符串列表
     */
    public static List<String> findSevenDaysByStartTime(String startDateTimeStr) {
        List<String> dateList = new ArrayList<>();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        // 先解析字符串为LocalDateTime
        LocalDateTime startDateTime = parseInputToLocalDateTime(startDateTimeStr);

        for (int i = 0; i < 7; i++) {
            LocalDateTime currentDate = startDateTime.plusDays(i);
            dateList.add(currentDate.format(formatter));
        }

        return dateList;
    }

    // 测试方法：验证两种输出（00:00:00 和 23:59:59）
//    public static void main(String[] args) {
//        // 测试1：纯日期输入
//        System.out.println(formatToStartOfDay("2025-09-12")); // 输出：2025-09-12 00:00:00
//        System.out.println(formatToEndOfDay("2025-09-12"));   // 输出：2025-09-12 23:59:59
//
//        // 测试2：带T分隔的时间输入
//        System.out.println(formatToStartOfDay("2025-09-12T10:02:23")); // 输出：2025-09-12 00:00:00
//        System.out.println(formatToEndOfDay("2025-09-12T10:02:23"));   // 输出：2025-09-12 23:59:59
//
//        // 测试3：带空格分隔的时间输入
//        System.out.println(formatToStartOfDay("2025-09-12 10:02:23")); // 输出：2025-09-12 00:00:00
//        System.out.println(formatToEndOfDay("2025-09-12 10:02:23"));   // 输出：2025-09-12 23:59:59
//    }
}
